home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 8: LINUX Games / Linux Cubed Series 8 - LINUX Games.iso / games / x11 / video / xevil-1.000 / xevil-1 / world.h < prev    next >
C/C++ Source or Header  |  1995-07-29  |  10KB  |  280 lines
  1. // "world.h"
  2. // TAG:  W
  3. /*    Copyright (C) 1994  Steve Hardt
  4.  
  5.     This program is free software; you can redistribute it and/or modify
  6.     it under the terms of the GNU General Public License as published by
  7.     the Free Software Foundation; either version 1, or (at your option)
  8.     any later version.
  9.  
  10.     This program is distributed in the hope that it will be useful,
  11.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.     GNU General Public License for more details.
  14.  
  15.     You should have received a copy of the GNU General Public License
  16.     along with this program; if not, write to the Free Software
  17.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18.  
  19.     Steve Hardt 
  20.     hardts@athena.mit.edu hardts@media.mit.edu
  21.     hardts@r4002.3dem.bioch.bcm.tmc.edu
  22.     2043 McClendon
  23.     Houston, TX 77030
  24. */
  25.  
  26. /* Overview:  A world object is a rectangular region composed of WSQUARES.
  27.    Internally, it is divided into rooms of constant size.  It's upper left 
  28.    corner is at WSQUARE (0,0). 
  29.    World should be draw completely once before just drawing with changes. */
  30.  
  31. #ifndef WORLD_H
  32. #define WORLD_H
  33.  
  34. #ifndef NO_PRAGMAS
  35. #pragma interface
  36. #endif
  37.  
  38. // Include Files
  39. #include "utils.h"
  40. #include "coord.h"
  41. #include "area.h"
  42.  
  43.  
  44. // Defines.
  45. // WSQUARES in a room.
  46. #define W_ROOM_COL_MAX 40//36
  47. #define W_ROOM_ROW_MAX 16//15 
  48.  
  49. /* Maximum rooms in world.  World may actually be smaller.  World starts out 
  50.    at the size of the title screen. */
  51. #define W_ACROSS_MAX_MAX 15
  52. #define W_DOWN_MAX_MAX 15
  53.  
  54. // WSQUARES in world.
  55. #define W_COL_MAX_MAX (W_ROOM_COL_MAX * W_ACROSS_MAX_MAX)
  56. #define W_ROW_MAX_MAX (W_ROOM_ROW_MAX * W_DOWN_MAX_MAX)
  57.  
  58. /* The maximum number of wsquares that can be set changed/unchanged in one 
  59.   clock cycle. */
  60. #define W_CHANGES_MAX 5000
  61.  
  62. /* The blocks composing the world.  Represented as integers so that the world
  63.    map can be initialized easily. */
  64.  
  65.  
  66. enum { Wempty, Wwall, Wladder, Woutside, Wsquanch, WupDown, WtextSquare};
  67. #define W_BLOCKS_NUM 7
  68.  
  69. enum Wsig {W_NO_SIG, W_CLOSE, W_CLOSE_BAD, W_FAILURE};
  70.  
  71. // No more Wmap
  72.  
  73. #define W_POSTERS_NUM 13
  74. class Blueprints;
  75.  
  76.  
  77.  
  78. // Class Declarations
  79. class World {
  80.   struct Wxdata {
  81.     Pixel background[Xvars::DISPLAYS_MAX]; 
  82.     Pixmap pixmaps[Xvars::DISPLAYS_MAX][W_BLOCKS_NUM];
  83.     // Array of pixmaps for a poster with columns changing fastest.
  84.     Pixmap *posterPixmaps[Xvars::DISPLAYS_MAX][W_POSTERS_NUM];  
  85.   };
  86.  
  87.   struct PosterSquare {
  88.     int poster;
  89.     Loc loc; // Inside poster.
  90.   };
  91.  
  92.  
  93.  public:
  94.   World(Boolean pol_correct);
  95.   /* EFFECTS: Create the title screen world.  If politically correct, 
  96.    there will be no posters and the title screen will be blank. */
  97.  
  98.   Size get_size() {return size;}
  99.   /* EFFECTS: Size of the world in pixels. */
  100.  
  101.   Dim get_dim() {return dim;}
  102.   /* EFFECTS: Dimensions of the world in wsquares. */
  103.  
  104.   Dim get_room_dim();
  105.   /* EFFECTS: Return the dimensions of a room in wsquares. */
  106.  
  107.   Size get_room_size();
  108.  
  109.   Rooms get_rooms() {return rooms;}
  110.   /* EFFECTS: The max number of rooms in across and down direction. */
  111.  
  112.   void set_rooms_next(const Rooms &r);
  113.   /* EFFECTS: After the next reset, the world will have as many rooms as r.
  114.    If r is bigger than the maximum, the min of the maximum size and r is 
  115.    used. */
  116.  
  117.   void set_map_print(Boolean val) {mapPrint = val;}
  118.   /* EFFECTS: Sets whether to print each new map of the world at reset. */
  119.  
  120.   Boolean overlap(const Box &box);
  121.   /* EFFECTS: Does any of box overlap with the wsquares of the world. */
  122.  
  123.   void draw(Drawable buffer,Xvars &xv,int dpyNum,const Box &box);
  124.   /* EFFECTS: Draw all of the box that is in the world. */
  125.  
  126.   void draw(Drawable buffer,Xvars &xv,int dpyNum,const Area &area);
  127.   /* EFFECTS: Draw all of area that is in the world. */
  128.  
  129.   Boolean inside(const Loc &l)
  130.     {return l.r >= 0 && l.c >= 0 && l.r < dim.rowMax && l.c < dim.colMax;}
  131.   /* EFFECTS: Returns True if loc is a wsquare inside the world, otherwise
  132.    returns False. */
  133.  
  134.   Boolean open(const Loc &loc,Boolean laddersClosed = False,
  135.            Boolean postersClosed = False);
  136.   /* EFFECTS: Returns True if loc is an open square inside the world.  Returns
  137.      False otherwise.  Note that wsquares outside the world are treated as if 
  138.      they were closed wsquares. */
  139.  
  140.   Boolean open(const Area &area,Boolean laddersClosed = False);
  141.   Boolean open(const Box &box,Boolean laddersClosed = False,
  142.            Boolean postersClosed = False);
  143.   /* EFFECTS: Is the portion of the world covered by area (or box) blocked? 
  144.      laddersClosed implies that ladders and other non-walls are considered to be
  145.      blocking. */
  146.  
  147.   
  148.  
  149.   Wsig open_offset(Size &offset,const Area &area,
  150.            const Vel &vel,Boolean laddersClosed = False);
  151.   /* MODIFIES: offset  */
  152.   /* EFFECTS: Returns W_NO_SIG if the portion of the world covered by initial 
  153.      is open.  prev is the previous area occupied before.  If the area is 
  154.      blocked, but a nearby area is not, returns
  155.      W_CLOSE_OK and sets offset to be the offset necessary to unblock initial.
  156.      Retruns W_CLOSE_BLOCKED if a nearby area is blocked.  Stills sets offset
  157.      for the nearby area.  Returns W_FAILURE if initial and all nearby areas 
  158.      are blocked.  offset may be modified in any case. */
  159.  
  160.   void touchingHanging(Touching &touching, Hanging &hanging, 
  161.                const Area &area);
  162.   /* REQUIRES: area is AR_RECT. */
  163.   /* MODIFIES: touching, hanging */
  164.   /* EFFECTS: If area is touching a blocked wsquare, sets touching to be the 
  165.      direction from area to the wsquare.  If the area is touching in both the
  166.      vertical and horizontal direction, the vertical takes precedence.  Sets
  167.      touching to be CO_air if not touching in any direction.  If the area is
  168.      hanging off of the edge of some blocked wsquares, sets hanging 
  169.      appropriately.  Otherwise, sets hanging.corner to be CO_air. */
  170.   
  171.   Boolean canClimb(const Loc &loc)
  172.     {return inside(loc) ? (map[loc.r][loc.c] == Wladder) : False;}
  173.   /* EFFECTS: Returns True if loc is a climable square inside the world.  I.e.
  174.      a ladder.  False otherwise. */
  175.  
  176.   Pos empty_rect(const Size &size);
  177.   /* EFFECTS: Return the upper-left position of a randomly choosen empty 
  178.      rectangle of size s.  Ladders are not considered empty. */
  179.  
  180.   Pos empty_touching_rect(const Size &size);
  181.   /* EFFECTS: Like empty_rect except the returned rect will be touching the 
  182.      ground. */
  183.  
  184.   Pos empty_accessible_rect(const Size &size);
  185.   /* EFFECTS: Like empty_rect except that it guarantees that the rectangle can
  186.      be reached by all Creatures.  Also, the returned rectangle will be 
  187.      touching CO_dn. */
  188.   /* REQUIRES: reset() has been called. */
  189.  
  190.   Boolean empty_box(Loc &loc,const Dim &dim,Boolean laddersClosed,
  191.             Boolean postersClosed);
  192.   /* MODIFIES: loc */
  193.   /* EFFECTS: Returns True iff an empty box of dimension dim can be found and
  194.      returns its upper-left Loc. */
  195.  
  196.   void reset();
  197.   /* EFFECTS:  Prepare the world for a new game.  Create a new map. */
  198.  
  199.   void clock() {} 
  200.   
  201.  
  202.  private:
  203.   void draw_square(Drawable buffer,Xvars &xvars,int dpyNum,const Loc &loc,
  204.            int x,int y);
  205.  
  206.   /* EFFECTS: Draw the appropriate square from loc to (x,y) on buffer. */
  207.  
  208.   void dim_size_update();
  209.   /* EFFECTS: Updates dim and size from the current value of rooms. */
  210.  
  211.   void init_x(Xvars &);
  212.   /* EFFECTS: Initialize all x dependencies. */
  213.  
  214.   void title_map();
  215.  
  216.   void th_helper(Touching &touching,Hanging &hanging,
  217.          const TouchingListItem &item,
  218.          Boolean r_c,
  219.          int coord,int length,
  220.          int wsquare_length,
  221.          Touching iftouching,
  222.          Corner ifsmall, Corner iflarge);
  223.   /* MODIFIES: touching, hanging */
  224.   /* EFFECTS: Helper for World::touching.  Does touching, hanging for one 
  225.      side. */
  226.  
  227.   Boolean open_iter(Area &area,int &changed,Dir dir,Boolean laddersClosed);
  228.   /* MODIFIES: area, changed */
  229.   /* EFFECTS: Move area as much in dir as necessary to avoid all its wsquares.
  230.      Increment changed by the distance moved.  Return True if the original 
  231.      area is open and nothing is changed.*/
  232.  
  233.   Size open_size(int offset,Dir dir);
  234.   Size open_size(int offset1,Dir dir1,int offset2,Dir dir2);
  235.   /* REQUIRES: dir is in {CO_R, CO_DN, CO_L, CO_UP} */
  236.   /* EFFECTS: Return the Size corresponding to an offset in one or two 
  237.      directions. */
  238.  
  239.   Boolean open_try_dirs(Size &offset,const Area &area,const Dir dirs[4],
  240.                    int dirsNum,Boolean laddersClosed);
  241.   /* MODIFIES: offset */
  242.   /* EFFECTS: Sets offset to be the minimum necessary to shift area to an
  243.      open area in one of the directions of dirs.  Returns whether it 
  244.      succeeded.  offset may be changed in any case. */
  245.   
  246.   Boolean open_try_diagonals(Size &offset,const Area &area,
  247.                    Boolean laddersClosed);
  248.   /* MODIFIES: offset */
  249.   /* EFFECTS: Set offset to shift area to a nearby open one.  Returns whether
  250.      it succeeded.  offset may be changed in any case. */
  251.  
  252.   Rooms rooms,roomsNext;
  253.   Size size;  /* For convenience only. */
  254.   Dim dim;    /* For convenience only. */
  255.  
  256.   char map[W_ROW_MAX_MAX][W_COL_MAX_MAX];
  257.   Boolean xValid;
  258.   Wxdata xdata;
  259.   Boolean mapPrint;
  260.   Dim posterDims[W_POSTERS_NUM]; 
  261.   PosterSquare *posterSquares[W_ROW_MAX_MAX][W_COL_MAX_MAX];
  262.   Boolean polCorrect;
  263.   Blueprints *blueprints;
  264.  
  265.   // Defined in world.bitmaps.
  266.   static char *posterPixmapBits[W_POSTERS_NUM];
  267.   static char *posterMaskBits[W_POSTERS_NUM];
  268.   static const Size posterSizes[W_POSTERS_NUM];
  269.   static const char *posterForegrounds[W_POSTERS_NUM];
  270.   static const char *posterBackgrounds[W_POSTERS_NUM];
  271.   static char *pixmapBits[W_BLOCKS_NUM];
  272.   static const char *colorNames[W_BLOCKS_NUM];
  273. };
  274.  
  275.                
  276.  
  277. // Typdefs
  278.   typedef World *WorldP;
  279. #endif
  280.